/*
 *所有关于Bus_合同分拆报工类的业务代码应在此处编写
*可使用repository.调用常用方法，获取EF/Dapper等信息
*如果需要事务请使用repository.DbContextBeginTransaction
*也可使用DBServerProvider.手动获取数据库相关信息
*用户信息、权限、角色等使用UserContext.Current操作
*Bus_合同分拆报工Service对增、删、改查、导入、导出、审核业务代码扩展参照ServiceFunFilter
*/
using VOL.Core.BaseProvider;
using VOL.Core.Extensions.AutofacManager;
using VOL.Entity.DomainModels;
using System.Linq;
using VOL.Core.Utilities;
using System.Linq.Expressions;
using VOL.Core.Extensions;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.AspNetCore.Http;
using VOL.Order.IRepositories;
using VOL.Entity.dtomodel;
using Mapster;
using System;
using VOL.Core.ManageUser;
using System.Collections.Generic;
using VOL.Core.DBManager;
using VOL.Order.Repositories;
using System.Net;
using Newtonsoft.Json;
using EFCore.BulkExtensions;

namespace VOL.Order.Services
{
    public partial class Bus_合同分拆报工Service
    {
        private readonly IHttpContextAccessor _httpContextAccessor;
        private readonly IBus_合同分拆报工Repository _repository;//访问数据库
        private readonly IDic_班组字典Repository _dic班组字典Repository;
        private readonly IDic_班组人员Repository _dic班组人员Repository;
        private readonly IBus_合同主表Repository _repository合同主表;
        private readonly IBus_合同分拆Repository _repository合同分拆;
        private readonly IBus_合同分拆确认Repository _repository合同分拆确认;
        private readonly IBus_合同分拆报工指标Repository _repository合同分拆报工指标;
        private readonly IBus_合同分拆报工人员明细Repository _repositoryBus_合同分拆报工人员明细;
        private readonly IDic_单据状态Repository _repositoryDic_单据状态Repository;

        [ActivatorUtilitiesConstructor]
        public Bus_合同分拆报工Service(
            IBus_合同分拆报工Repository dbRepository,
            IDic_班组字典Repository dic班组字典Repository,
            IDic_班组人员Repository dic班组人员Repository,
            IHttpContextAccessor httpContextAccessor,
            IBus_合同分拆Repository repository合同分拆,
            IBus_合同主表Repository repository合同主表,
            IBus_合同分拆确认Repository repository合同分拆确认,
          IBus_合同分拆报工指标Repository repository合同分拆报工指标,
          IDic_单据状态Repository repositoryDic_单据状态Repository,
         IBus_合同分拆报工人员明细Repository repositoryBus_合同分拆报工人员明细
            )
        : base(dbRepository)
        {
            _httpContextAccessor = httpContextAccessor;
            _repository = dbRepository;
            _dic班组字典Repository = dic班组字典Repository;
            _dic班组人员Repository = dic班组人员Repository;
            _repository合同主表 = repository合同主表;
            _repository合同分拆 = repository合同分拆;
            _repository合同分拆确认 = repository合同分拆确认;
            _repository合同分拆报工指标 = repository合同分拆报工指标;
            _repositoryBus_合同分拆报工人员明细 = repositoryBus_合同分拆报工人员明细;
            _repositoryDic_单据状态Repository = repositoryDic_单据状态Repository;
            //多租户会用到这init代码，其他情况可以不用
            //base.Init(dbRepository);
        }

        #region 自建报工
        /// <summary>
        /// 自建疏通提交（未完工）
        /// </summary>
        /// <param name="合同分拆报工dtos"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        //public int ZiJianShuTongSubmitNotFinish(Bus_合同分拆报工DTO 合同分拆报工dtos,ref string message)
        //{
        //    Guid 报工次序guid = Guid.NewGuid();
        //    if (合同分拆报工dtos != null && 合同分拆报工dtos.bus_合同分拆报工List != null && 合同分拆报工dtos.bus_合同分拆报工List.Count > 0)
        //    {
        //        for (int i = 0; i < 合同分拆报工dtos.bus_合同分拆报工List.Count; i++)
        //        {
        //            var bus合同分拆确认 = _repository合同分拆确认
        //                        .Find(it => it.分拆编号 == 合同分拆报工dtos.bus_合同分拆报工List[0].分拆编号 &&
        //                        it.人员姓名 == 合同分拆报工dtos.bus_合同分拆报工List[0].施工人员).First();
        //            if (bus合同分拆确认.分拆状态 == "已完工")
        //            {
        //                message = $"分拆编号:{合同分拆报工dtos.bus_合同分拆报工List[0].分拆编号}-{合同分拆报工dtos.bus_合同分拆报工List[0].施工人员}的状态为{bus合同分拆确认.分拆状态}，不是【已派工】,无法报工";
        //                return 0;
        //            }
        //        }

        //        //便历本次所有人员报的时间是否冲突
        //        bool 冲突=false;
        //        for (int i = 0; i < 合同分拆报工dtos.bus_合同分拆报工List.Count; i++)
        //        {
        //            var bus合同分拆报工 = 合同分拆报工dtos.bus_合同分拆报工List[i];
        //            if (检查冲突( bus合同分拆报工.施工人员, bus合同分拆报工.施工开始时间, bus合同分拆报工.施工结束时间))
        //            {
        //                冲突=true;
        //                message = bus合同分拆报工.施工人员 + $"的报工时间冲突,当前时间段已经有报工!!";
        //                return 0;
        //            }
        //        }


        //        //根据合同分拆报工dtos的分拆编号和人员名称查出报工确认
        //        for (int i = 0; i < 合同分拆报工dtos.bus_合同分拆报工List.Count; i++)
        //        {
        //            var 合同分拆报工 = 合同分拆报工dtos.bus_合同分拆报工List[i];
        //            var bus合同分拆确认 = _repository合同分拆确认.Find(it => it.分拆编号 == 合同分拆报工.分拆编号 
        //                                                                        && it.人员姓名 == 合同分拆报工.施工人员).First();
        //            bus合同分拆确认.分拆状态 = "已报工"; 
        //            if (bus合同分拆确认 != null )
        //            {
        //                bus合同分拆确认.Adapt(合同分拆报工);
        //            }
        //            else
        //            {
        //                var 无合同分拆确认 = _repository合同分拆确认.Find(it => it.分拆编号 == 合同分拆报工.分拆编号).First();
        //                无合同分拆确认.班组id = null;
        //                无合同分拆确认.班组 = "";
        //                无合同分拆确认.人员id = null;
        //                无合同分拆确认.人员姓名 = "";
        //                无合同分拆确认.Adapt(合同分拆报工);
        //            }
        //            合同分拆报工.分拆状态 = "已报工";
        //            合同分拆报工.guid = Guid.NewGuid();
        //            合同分拆报工.报工次序guid = 报工次序guid;
        //            合同分拆报工.分拆确定guid = bus合同分拆确认.分拆guid;
        //            合同分拆报工.报工日期 = DateTime.Now;
        //            合同分拆报工.CreateDate = DateTime.Now;
        //            合同分拆报工.CreateID = UserContext.Current.UserId;
        //            合同分拆报工.Creator = UserContext.Current.UserName;
        //        }
        //    }
        //    //准备Bus_合同分拆报工指标
        //    var 分拆确认 = _repository合同分拆确认.Find(it => it.分拆编号 == 合同分拆报工dtos.bus_合同分拆报工List[0].分拆编号 &&
        //                                                        it.分拆guid == 合同分拆报工dtos.bus_合同分拆报工List[0].分拆确定guid).First();
        //    if (合同分拆报工dtos != null && 合同分拆报工dtos.bus_合同分拆报工指标List != null && 合同分拆报工dtos.bus_合同分拆报工指标List.Count > 0)
        //    {
        //        合同分拆报工dtos.bus_合同分拆报工指标List.ForEach(it =>
        //        {
        //            it.guid = Guid.NewGuid();
        //            it.报工次序guid = 报工次序guid;
        //            it.CreateDate = DateTime.Now;
        //            it.CreateID = UserContext.Current.UserId;
        //            it.Creator = UserContext.Current.UserName;
        //        });


        //        //塞入合同分拆报工
        //        _repository合同分拆报工指标.AddRange(合同分拆报工dtos.bus_合同分拆报工指标List);
        //    }
        //    _repository.AddRange(合同分拆报工dtos.bus_合同分拆报工List, true);
        //    message = "报工成功";
        //    return 1;
        //}

        public WebResponseContent ZiJianShuTongSubmit(Bus_合同分拆报工DTO 合同分拆报工dtos)
        {
            WebResponseContent webResponseContent = new WebResponseContent();
            Guid 报工guid = 合同分拆报工dtos.bus_合同分拆报工.guid;
            //如果已经提交过，就不允许再次提交
            var 已经提交过 = _repository.Find(it => it.guid == 合同分拆报工dtos.bus_合同分拆报工.guid).Any();
            if (已经提交过)
            {
                webResponseContent.Message = "已经提交,不要重复点击";
                return webResponseContent;
            }
            if (合同分拆报工dtos != null && 合同分拆报工dtos.bus_合同分拆报工人员明细List != null && 合同分拆报工dtos.bus_合同分拆报工人员明细List.Count > 0)
            {
                for (int i = 0; i < 合同分拆报工dtos.bus_合同分拆报工人员明细List.Count; i++)
                {
                    //判断是不是已经完工
                    var bus合同分拆确认 = _repository合同分拆确认
                                .Find(it => it.分拆guid == 合同分拆报工dtos.bus_合同分拆报工.分拆guid &&
                                it.人员姓名 == 合同分拆报工dtos.bus_合同分拆报工人员明细List[0].施工人员
                                && (it.分拆状态 == "已完工" || it.分拆状态.Contains("审核") ))
                                .FirstOrDefault();
                    //var bus合同分拆确认完工 = bus合同分拆确认.Where(it => it.分拆状态 == "已完工").ToList();
                    //if (bus合同分拆确认完工.Count > 0)
                    //{
                    //    webResponseContent.Message = $"分拆编号:{合同分拆报工dtos.bus_合同分拆报工.分拆编号}-{合同分拆报工dtos.bus_合同分拆报工人员明细List[0].施工人员}的状态为[{bus合同分拆确认完工[0].分拆状态}]，不是【已派工】,无法报工";
                    //    return webResponseContent;
                    //}
                    if (bus合同分拆确认 != null)
                    {
                        webResponseContent.Message = $"分拆编号:{合同分拆报工dtos.bus_合同分拆报工.分拆编号}-{合同分拆报工dtos.bus_合同分拆报工人员明细List[0].施工人员}的状态为[{bus合同分拆确认.分拆状态}],无法再次报工";
                        return webResponseContent;
                    }
                }

                //便历本次所有人员报的时间是否冲突
                bool 冲突 = false;
                for (int i = 0; i < 合同分拆报工dtos.bus_合同分拆报工人员明细List.Count; i++)
                {
                    var bus合同分拆报工 = 合同分拆报工dtos.bus_合同分拆报工人员明细List[i];
                    if (检查冲突(bus合同分拆报工.施工人员, bus合同分拆报工.施工开始时间, bus合同分拆报工.施工结束时间))
                    {
                        冲突 = true;
                        webResponseContent.Message = bus合同分拆报工.施工人员 + $"的报工时间冲突,当前时间段已经有报工!!";
                        return webResponseContent;
                    }
                }
                //检查通过，开始报工
                List<Dic_班组人员> dic_班组人员List = _dic班组人员Repository.Find(it => 1 == 1);

                //1将任务单赋值给报工，并且修改任务单的状态
                Bus_合同分拆 bus合同分拆 = _repository合同分拆.FindFirst(it => it.guid == 合同分拆报工dtos.bus_合同分拆报工.分拆guid);
                //修改任务单状态
                bus合同分拆.分拆状态 = 合同分拆报工dtos.分拆状态;
                bus合同分拆.最近报工时间 = DateTime.Now;

                TypeAdapterConfig<Bus_合同分拆, Bus_合同分拆报工>.NewConfig()
                     .Ignore(dest => dest.单位) // 忽略特定字段
                     .Ignore(dest => dest.施工内容)
                     .Ignore(dest => dest.道路信息)
                     .Ignore(dest => dest.guid);

                //任务单赋值给报工
                bus合同分拆.Adapt(合同分拆报工dtos.bus_合同分拆报工);
                合同分拆报工dtos.bus_合同分拆报工.guid = 报工guid;
                //合同分拆报工dtos.bus_合同分拆报工.报工班组 = UserContext.Current.UserName;
                合同分拆报工dtos.bus_合同分拆报工.分拆状态 = 合同分拆报工dtos.分拆状态;
                合同分拆报工dtos.bus_合同分拆报工.报工日期 = DateTime.Now;
                合同分拆报工dtos.bus_合同分拆报工.CreateDate = DateTime.Now;
                合同分拆报工dtos.bus_合同分拆报工.CreateID = UserContext.Current.UserId;
                合同分拆报工dtos.bus_合同分拆报工.Creator = UserContext.Current.UserName;
                合同分拆报工dtos.bus_合同分拆报工.时间跨度 = (decimal?)(合同分拆报工dtos.bus_合同分拆报工.施工结束时间 - 合同分拆报工dtos.bus_合同分拆报工.施工开始时间).Value.TotalHours;


                List<Bus_合同分拆确认> bus合同分拆确认List = new List<Bus_合同分拆确认>();
                //2给bus_合同分拆报工人员明细List赋值
                if (合同分拆报工dtos.bus_合同分拆报工人员明细List != null && 合同分拆报工dtos.bus_合同分拆报工人员明细List.Count > 0)
                {
                    foreach (var item in 合同分拆报工dtos.bus_合同分拆报工人员明细List)
                    {
                        item.guid = Guid.NewGuid();
                        item.合同分拆报工guid = 合同分拆报工dtos.bus_合同分拆报工.guid;
                        item.班组 = dic_班组人员List?.Where(it => it.人员 == item.施工人员).FirstOrDefault()?.班组;
                        item.班组id = dic_班组人员List?.Where(it => it.人员 == item.施工人员).FirstOrDefault()?.guid;
                        item.分配系数 = dic_班组人员List?.Where(it => it.人员 == item.施工人员).FirstOrDefault()?.分配系数;
                        //计算施工开始时间和结束时间的小时数
                        item.作业工时 = (decimal?)(item.施工结束时间 - item.施工开始时间).Value.TotalHours;
                        item.CreateDate = DateTime.Now;
                        item.CreateID = UserContext.Current.UserId;
                        item.Creator = UserContext.Current.UserName;

                        //4修改bus_合同分拆确认的状态
                        Bus_合同分拆确认 bus合同分拆确认 = _repository合同分拆确认.Find(it =>
                                                                    it.分拆guid == 合同分拆报工dtos.bus_合同分拆报工.分拆guid &&
                                                                    it.人员姓名 == item.施工人员).First();
                        if (bus合同分拆确认 != null)
                        {
                            bus合同分拆确认.分拆状态 = 合同分拆报工dtos.分拆状态;
                            bus合同分拆确认List.Add(bus合同分拆确认);
                        }
                    }
                }
                //3给bus_合同分拆报工指标List赋值
                if (合同分拆报工dtos.bus_合同分拆报工指标List != null && 合同分拆报工dtos.bus_合同分拆报工指标List.Count > 0)
                {
                    foreach (var item in 合同分拆报工dtos.bus_合同分拆报工指标List)
                    {
                        item.guid = Guid.NewGuid();
                        item.CreateDate = DateTime.Now;
                        item.CreateID = UserContext.Current.UserId;
                        item.Creator = UserContext.Current.UserName;
                        item.合同分拆报工guid = 合同分拆报工dtos.bus_合同分拆报工.guid;
                    }
                }

                //更新到数据库

                //事务
                WebResponseContent webResponse = repository.DbContextBeginTransaction(() =>
                {
                    try
                    {
                        if (bus合同分拆 != null)
                        {
                            _repository合同分拆.Update(bus合同分拆, true);
                        }
                        if (bus合同分拆确认List != null)
                        {
                            _repository合同分拆确认.UpdateRange(bus合同分拆确认List, true);
                        }
                        if (合同分拆报工dtos.bus_合同分拆报工人员明细List != null)
                        {
                            _repositoryBus_合同分拆报工人员明细.AddRange(合同分拆报工dtos.bus_合同分拆报工人员明细List, true);
                        }
                        if (合同分拆报工dtos.bus_合同分拆报工指标List != null)
                        {
                            _repository合同分拆报工指标.AddRange(合同分拆报工dtos.bus_合同分拆报工指标List, true);
                        }
                        if (合同分拆报工dtos.bus_合同分拆报工 != null)
                        {
                            _repository.Add(合同分拆报工dtos.bus_合同分拆报工, true);
                        }
                        //如果想要回滚，返回new WebResponseContent().Error("返回消息")
                        return new WebResponseContent().OK();
                    }
                    catch (Exception ex)
                    {
                        VOL.Core.Services.Logger.Info("2班组提交报工,数据库报错:" + ex.StackTrace);
                        return new WebResponseContent().Error("报工失败");
                        throw;
                    }
                });
                if (webResponse.Status)
                {
                    webResponse.Message = "报工成功";
                }
                else
                {
                    webResponse.Message = "报工失败";
                }
                //if (bus合同分拆 != null)
                //{
                //    _repository合同分拆.Update(bus合同分拆, true);
                //}
                //if (bus合同分拆确认List != null)
                //{
                //    _repository合同分拆确认.UpdateRange(bus合同分拆确认List, true);

                //}
                //if (合同分拆报工dtos.bus_合同分拆报工人员明细List != null)
                //{
                //    _repositoryBus_合同分拆报工人员明细.AddRange(合同分拆报工dtos.bus_合同分拆报工人员明细List, true);
                //}
                //if (合同分拆报工dtos.bus_合同分拆报工指标List != null)
                //{
                //    _repository合同分拆报工指标.AddRange(合同分拆报工dtos.bus_合同分拆报工指标List, true);
                //}
                //if (合同分拆报工dtos.bus_合同分拆报工 != null)
                //{
                //    _repository.Add(合同分拆报工dtos.bus_合同分拆报工, true);
                //}
                return webResponse;
            }


            //_repository.AddRange(合同分拆报工dtos.bus_合同分拆报工List, true);
            webResponseContent.Message = "报工数据不能为空";
            return webResponseContent;
        }



        private bool 检查冲突(string 施工人员, DateTime? 施工开始时间, DateTime? 施工结束时间)
        {
            bool flag = false;
            //string sql;
            //    sql = $"select * from Bus_合同分拆报工 where 施工人员='{施工人员}' " +
            //    $"and (施工开始时间 between '{施工开始时间}' and '{施工结束时间}' or 施工结束时间 between '{施工开始时间}' and '{施工结束时间}')";
            //有返回值说明冲突
            flag = _repositoryBus_合同分拆报工人员明细.Find(x => x.施工人员 == 施工人员 &&
            (
                 (施工开始时间 <= x.施工开始时间 && x.施工开始时间 < 施工结束时间) ||
                 (施工开始时间 < x.施工结束时间 && x.施工结束时间 < 施工结束时间) ||
                 (x.施工开始时间 <= 施工开始时间 && 施工开始时间 < x.施工结束时间) ||
                 (x.施工开始时间 < 施工结束时间 && 施工结束时间 <= x.施工结束时间)
            )
            ).Any();

            return flag;

        }
        private bool 检查冲突(Guid 合同分拆报工guid, string 施工人员, DateTime? 施工开始时间, DateTime? 施工结束时间)
        {
            bool flag = false;
            string sql;
            sql = $"select * from Bus_合同分拆报工 where 施工人员='{施工人员}' and 合同分拆报工guid <> '{合同分拆报工guid}'" +
            $"and (施工开始时间 between '{施工开始时间}' and '{施工结束时间}' or 施工结束时间 between '{施工开始时间}' and '{施工结束时间}')";
            //有返回值说明冲突
            flag = _repositoryBus_合同分拆报工人员明细.Find(x => x.施工人员 == 施工人员
            && x.合同分拆报工guid != 合同分拆报工guid &&
            (
                 (施工开始时间 <= x.施工开始时间 && x.施工开始时间 < 施工结束时间) ||
                 (施工开始时间 < x.施工结束时间 && x.施工结束时间 < 施工结束时间) ||
                 (x.施工开始时间 <= 施工开始时间 && 施工开始时间 < x.施工结束时间) ||
                 (x.施工开始时间 < 施工结束时间 && 施工结束时间 <= x.施工结束时间)
            )
            ).Any();


            return flag;

        }

        //public int ZiJianShuTongSubmitFinished(Bus_合同分拆报工DTO 合同分拆报工dtos, ref string message)
        //{
        //    if (合同分拆报工dtos != null && 合同分拆报工dtos.bus_合同分拆报工List != null && 合同分拆报工dtos.bus_合同分拆报工List.Count > 0)
        //    {

        //        var 合同分拆确认状态 = _repository合同分拆确认.Find(it => it.分拆编号 == 合同分拆报工dtos.bus_合同分拆报工List[0].分拆编号).First();
        //        if (合同分拆确认状态 == null || 合同分拆确认状态.分拆状态 != "已派工")
        //        {
        //            message = $"分拆编号:{合同分拆报工dtos.bus_合同分拆报工List[0].分拆编号}的状态为【合同分拆确认状态.分拆状态】，不是【已派工】,无法报工";
        //            return 0;
        //        }

        //        //根据合同分拆报工dtos的分拆编号和人员名称查出报工确认
        //        for (int i = 0; i < 合同分拆报工dtos.bus_合同分拆报工List.Count; i++)
        //        {
        //            var 合同分拆报工 = 合同分拆报工dtos.bus_合同分拆报工List[i];

        //            var 合同分拆确认 = _repository合同分拆确认.Find(it => it.分拆编号 == 合同分拆报工.分拆编号 && it.人员姓名 == 合同分拆报工.施工人员).First();
        //            if (合同分拆确认 != null )
        //            {
        //                合同分拆确认.Adapt(合同分拆报工);
        //            }
        //            else
        //            {
        //                var 无合同分拆确认 = _repository合同分拆确认.Find(it => it.分拆编号 == 合同分拆报工.分拆编号).First();
        //                无合同分拆确认.班组id = null;
        //                无合同分拆确认.班组 = "";
        //                无合同分拆确认.人员id = null;
        //                无合同分拆确认.人员姓名 = "";
        //                无合同分拆确认.Adapt(合同分拆报工);
        //            }
        //            合同分拆报工.分拆状态 = "已完工";
        //            合同分拆报工.guid = Guid.NewGuid();
        //            合同分拆报工.分拆确定guid = 合同分拆确认.guid;
        //            合同分拆报工.报工日期 = DateTime.Now;
        //            合同分拆报工.CreateDate = DateTime.Now;
        //            合同分拆报工.CreateID = UserContext.Current.UserId;
        //            合同分拆报工.Creator = UserContext.Current.UserName;

        //        }
        //        //根据分拆编号设置已完工
        //        var 分拆确认 = _repository合同分拆确认.Find(it => it.分拆编号 == 合同分拆报工dtos.bus_合同分拆报工List[0].分拆编号).First();
        //        分拆确认.分拆状态 = "已完工";

        //        WebResponseContent webResponse = repository.DbContextBeginTransaction(() =>
        //        {
        //            try
        //            {
        //                _repository合同分拆确认.Update(分拆确认, true);
        //                //塞入合同分拆报工
        //                _repository.AddRange(合同分拆报工dtos.bus_合同分拆报工List, true);
        //                //如果想要回滚，返回new WebResponseContent().Error("返回消息")
        //                return new WebResponseContent().OK();
        //            }
        //            catch (Exception ex)
        //            {
        //                return new WebResponseContent().Error("报工失败失败");
        //                throw;
        //            }
        //        });

        //        if (webResponse.Status)
        //        {
        //            message = "报工成功";
        //            return 1;
        //        }
        //        else
        //        {
        //            message = "报工失败";
        //            return 0;
        //        }

        //    }
        //    return 1;
        //}
        public List<Bus_合同分拆报工> GetBanZuYiBaoGongList(Bus_合同分拆报工 bus)
        {
            List<Bus_合同分拆报工> bus_合同分拆报工List = _repository.Find(it => it.Creator == UserContext.Current.UserName)
                                                                   .OrderByDescending(it => it.CreateDate).ToList();
            //_repository多条件查询
            string sql = "select * from Bus_合同分拆报工 where 1=1";
            if (string.IsNullOrEmpty(bus.总包合同项目名称) == false)
            {
                sql += $" and 总包合同项目名称 like '%{bus.总包合同项目名称}%'";
            }
            if (string.IsNullOrEmpty(bus.任务名称) == false)
            {
                sql += $" and 任务名称 like '%{bus.任务名称}%'";
            }
            sql += $" and Creator = '{UserContext.Current.UserName}'";
            sql += " order by CreateDate desc";
            bus_合同分拆报工List = DBServerProvider.SqlDapper.QueryList<Bus_合同分拆报工>(sql, null);
            return bus_合同分拆报工List;
        }

        /// <summary>
        /// 查询班组报工详细信息
        /// </summary>
        /// <param name="bus"></param>
        /// <returns></returns>
        public Bus_合同分拆报工DTO GetBanZuYiBaoGongDetail(Bus_合同分拆报工 bus)
        {
            Bus_合同分拆报工DTO bus_合同分拆报工DTO = new Bus_合同分拆报工DTO();
            Bus_合同分拆报工 bus_ = _repository.FindFirst(it => it.guid == bus.guid);
            bus_合同分拆报工DTO.bus_合同分拆报工 = bus_;
            bus_合同分拆报工DTO.bus_合同分拆报工人员明细List = _repositoryBus_合同分拆报工人员明细
                                                        .Find(it => it.合同分拆报工guid == bus_.guid).ToList();
            bus_合同分拆报工DTO.bus_合同分拆报工指标List = _repository合同分拆报工指标
                                                            .Find(it => it.合同分拆报工guid == bus_.guid).ToList();
            return bus_合同分拆报工DTO;
        }

        /// <summary>
        /// 更新报工信息
        /// </summary>
        /// <param name="合同分拆报工dtos"></param>
        /// <returns></returns>
        public WebResponseContent UpdateZiJianBaoGong(Bus_合同分拆报工DTO 合同分拆报工dtos)
        {
            WebResponseContent webResponseContent = new WebResponseContent();

            if (合同分拆报工dtos != null && 合同分拆报工dtos.bus_合同分拆报工 != null && 合同分拆报工dtos.bus_合同分拆报工人员明细List != null && 合同分拆报工dtos.bus_合同分拆报工人员明细List.Count > 0)
            {
                ////如果bus.CreateDate不是今天，就不允许删除
                //if (合同分拆报工dtos.bus_合同分拆报工.CreateDate.Value.Date != DateTime.Now.Date)
                //{
                //    webResponseContent.Message = "只能修改当天的报工,跨天的不能修改";
                //    webResponseContent.Code = "1";
                //    return webResponseContent;
                //}
                //根据bus.分拆状态查dic单据状态
                var dic单据状态 = _repositoryDic_单据状态Repository.Find(it => it.单据名称 == "Bus_合同分拆报工" && it.单据状态名称 == 合同分拆报工dtos.bus_合同分拆报工.分拆状态).First();
                //如果bus.分拆状态是已审核，就不允许删除
                if (dic单据状态.可编辑 == false)
                {
                    webResponseContent.Message = $"已[{合同分拆报工dtos.bus_合同分拆报工.分拆状态}]的报工不能修改";
                    webResponseContent.Code = "1";
                    return webResponseContent;
                }

                //便历本次所有人员报的时间是否冲突
                bool 冲突 = false;
                for (int i = 0; i < 合同分拆报工dtos.bus_合同分拆报工人员明细List.Count; i++)
                {
                    var bus合同分拆报工 = 合同分拆报工dtos.bus_合同分拆报工人员明细List[i];
                    if (检查冲突(bus合同分拆报工.合同分拆报工guid.GetValueOrDefault(), bus合同分拆报工.施工人员, bus合同分拆报工.施工开始时间, bus合同分拆报工.施工结束时间))
                    {
                        冲突 = true;
                        webResponseContent.Message = bus合同分拆报工.施工人员 + $"的报工时间冲突,当前时间段已经有报工!!";
                        return webResponseContent;
                    }
                }

                合同分拆报工dtos.bus_合同分拆报工.ModifyDate = DateTime.Now;
                合同分拆报工dtos.bus_合同分拆报工.ModifyID = UserContext.Current.UserId;
                合同分拆报工dtos.bus_合同分拆报工.Modifier = UserContext.Current.UserName;

                //2给bus_合同分拆报工人员明细List赋值
                if (合同分拆报工dtos.bus_合同分拆报工人员明细List != null && 合同分拆报工dtos.bus_合同分拆报工人员明细List.Count > 0)
                {
                    foreach (var item in 合同分拆报工dtos.bus_合同分拆报工人员明细List)
                    {
                        //计算施工开始时间和结束时间的小时数
                        item.作业工时 = (decimal?)(item.施工结束时间 - item.施工开始时间).Value.TotalHours;
                        item.ModifyDate = DateTime.Now;
                        item.ModifyID = UserContext.Current.UserId;
                        item.Modifier = UserContext.Current.UserName;
                    }
                }
                //3给bus_合同分拆报工指标List赋值
                if (合同分拆报工dtos.bus_合同分拆报工指标List != null && 合同分拆报工dtos.bus_合同分拆报工指标List.Count > 0)
                {
                    foreach (var item in 合同分拆报工dtos.bus_合同分拆报工指标List)
                    {
                        item.ModifyDate = DateTime.Now;
                        item.ModifyID = UserContext.Current.UserId;
                        item.Modifier = UserContext.Current.UserName;
                    }
                }

                //更新到数据库

                //事务
                WebResponseContent webResponse = repository.DbContextBeginTransaction(() =>
                {
                    try
                    {
                        if (合同分拆报工dtos.bus_合同分拆报工 != null)
                        {
                            _repository.Update(合同分拆报工dtos.bus_合同分拆报工, true);
                        }

                        if (合同分拆报工dtos.bus_合同分拆报工人员明细List != null && 合同分拆报工dtos.bus_合同分拆报工人员明细List.Count > 0)
                        {
                            _repositoryBus_合同分拆报工人员明细.UpdateRange(合同分拆报工dtos.bus_合同分拆报工人员明细List, true);
                        }

                        if (合同分拆报工dtos.bus_合同分拆报工指标List != null && 合同分拆报工dtos.bus_合同分拆报工指标List.Count > 0)
                        {
                            _repository合同分拆报工指标.UpdateRange(合同分拆报工dtos.bus_合同分拆报工指标List, true);
                        }

                        //如果想要回滚，返回new WebResponseContent().Error("返回消息")
                        return new WebResponseContent().OK();
                    }
                    catch (Exception ex)
                    {
                        VOL.Core.Services.Logger.Info("2班组提交报工,数据库报错:" + ex.StackTrace);
                        return new WebResponseContent().Error("修改失败");
                        throw;
                    }
                });
                if (webResponse.Status)
                {
                    webResponse.Message = "修改成功";
                }
                else
                {
                    webResponse.Message = "修改失败";
                }
                return webResponse;
            }


            //_repository.AddRange(合同分拆报工dtos.bus_合同分拆报工List, true);
            webResponseContent.Message = "报工数据不能为空";
            return webResponseContent;
        }

        //班组删除报工
        public WebResponseContent DeleteBanZuYiBaoGong(Bus_合同分拆报工 bus)
        {
            WebResponseContent webResponseContent = new WebResponseContent();
            Bus_合同分拆报工 bus_ = _repository.FindFirst(it => it.guid == bus.guid);
            if (bus_ != null)
            {
                //如果bus.CreateDate不是今天，就不允许删除
                //if (bus_.CreateDate.Value.Date != DateTime.Now.Date)
                //{
                //    webResponseContent.Message = "只能删除当天的报工,跨天的不能删除";
                //    webResponseContent.Code = "1";
                //    return webResponseContent;
                //}
                var dic单据状态 = _repositoryDic_单据状态Repository.Find(it => it.单据名称 == "Bus_合同分拆报工" && it.单据状态名称 == bus_.分拆状态).First();
                //如果bus.分拆状态是已审核，就不允许删除
                if (dic单据状态.可编辑 == false)
                {
                    webResponseContent.Message = $"已[{bus_.分拆状态}]的报工不能删除";
                    webResponseContent.Code = "1";
                    return webResponseContent;
                }

                //删除 Bus_合同分拆报工 和其它明细
                //通过事务删除
                WebResponseContent webResponse = repository.DbContextBeginTransaction(() =>
                {
                    try
                    {
                        _repository.Delete(bus_);
                        var a = _repositoryBus_合同分拆报工人员明细.Find(it => it.合同分拆报工guid == bus_.guid).ToList();
                        var b = _repository合同分拆报工指标.Find(it => it.合同分拆报工guid == bus_.guid).ToList();
                        if (a != null && a.Count > 0)
                        {
                            foreach (var item in a)
                            {
                                _repositoryBus_合同分拆报工人员明细.Delete(item, true);
                            }
                        }
                        if (b != null && b.Count > 0)
                        {
                            foreach (var item in b)
                            {
                                _repository合同分拆报工指标.Delete(item, true);
                            }
                        }
                        //如果想要回滚，返回new WebResponseContent().Error("返回消息")
                        return new WebResponseContent().OK("删除成功");
                    }
                    catch (Exception ex)
                    {
                        return new WebResponseContent().Error("删除失败");
                        throw;
                    }
                });
                return webResponse;
            }
            else
            {
                webResponseContent.Message = "未查到报工信息，可能已经删除";
                return webResponseContent;
            }

        }
        #endregion

        #region 外包报工
        public WebResponseContent WaiBaoSubmit(Bus_合同分拆报工DTO 合同分拆报工dtos)
        {
            WebResponseContent webResponseContent = new WebResponseContent();
            Guid 报工guid = 合同分拆报工dtos.bus_合同分拆报工.guid;
            //如果已经提交过，就不允许再次提交
            var 已经提交过 = _repository.Find(it => it.guid == 合同分拆报工dtos.bus_合同分拆报工.guid).Any();
            if (已经提交过)
            {
                webResponseContent.Message = "已经提交,不要重复点击";
                return webResponseContent;
            }
            string 班组长 = UserContext.Current.UserName;

            var dic = _dic班组字典Repository.FindFirst(it => it.组长 == 班组长);
            if (dic != null)
            {
                //判断是不是已经完工
                var bus合同分拆确认 = _repository合同分拆
                                    .Find(it => it.guid == 合同分拆报工dtos.bus_合同分拆报工.分拆guid
                                        && it.班组 == dic.班组
                                        && (it.分拆状态 == "已完工" || it.分拆状态 == "已审核"))
                                    .FirstOrDefault();

                if (bus合同分拆确认 != null)
                {
                    webResponseContent.Message = $"分拆编号:{合同分拆报工dtos.bus_合同分拆报工.分拆编号}-{dic.班组}的状态为[{bus合同分拆确认.分拆状态}],无法再次报工";
                    return webResponseContent;
                }
                //便历本次所有人员报的时间是否冲突
                bool 冲突 = false;
                if (检查外包报工时间冲突(dic.班组, 合同分拆报工dtos.bus_合同分拆报工.施工开始时间, 合同分拆报工dtos.bus_合同分拆报工.施工结束时间))
                {
                    冲突 = true;
                    webResponseContent.Message = UserContext.Current.UserName + $"的报工时间冲突,当前时间段已经有报工!!";
                    return webResponseContent;
                }

                //检查通过，开始报工
                List<Dic_班组人员> dic_班组人员List = _dic班组人员Repository.Find(it => 1 == 1);

                //1将任务单赋值给报工，并且修改任务单的状态
                Bus_合同分拆 bus合同分拆 = _repository合同分拆.FindFirst(it => it.guid == 合同分拆报工dtos.bus_合同分拆报工.分拆guid);
                if (bus合同分拆 == null )
                {
                    webResponseContent.Message = "未查询到项目经理派单记录，请联系管理员";
                    return webResponseContent;
                }
                //修改任务单状态
                bus合同分拆.分拆状态 = 合同分拆报工dtos.分拆状态;
                //任务单赋值给报工
                bus合同分拆.Adapt(合同分拆报工dtos.bus_合同分拆报工);
                合同分拆报工dtos.bus_合同分拆报工.guid = 报工guid;
                //合同分拆报工dtos.bus_合同分拆报工.报工班组 = UserContext.Current.UserName;
                合同分拆报工dtos.bus_合同分拆报工.分拆状态 = 合同分拆报工dtos.分拆状态;
                合同分拆报工dtos.bus_合同分拆报工.报工日期 = DateTime.Now;
                合同分拆报工dtos.bus_合同分拆报工.CreateDate = DateTime.Now;
                合同分拆报工dtos.bus_合同分拆报工.CreateID = UserContext.Current.UserId;
                合同分拆报工dtos.bus_合同分拆报工.Creator = UserContext.Current.UserName;
                合同分拆报工dtos.bus_合同分拆报工.时间跨度 = (decimal?)(合同分拆报工dtos.bus_合同分拆报工.施工结束时间 - 合同分拆报工dtos.bus_合同分拆报工.施工开始时间).Value.TotalHours;
                //3给bus_合同分拆报工指标List赋值
                if (合同分拆报工dtos.bus_合同分拆报工指标List != null && 合同分拆报工dtos.bus_合同分拆报工指标List.Count > 0)
                {
                    foreach (var item in 合同分拆报工dtos.bus_合同分拆报工指标List)
                    {
                        item.guid = Guid.NewGuid();
                        item.CreateDate = DateTime.Now;
                        item.CreateID = UserContext.Current.UserId;
                        item.Creator = UserContext.Current.UserName;
                        item.合同分拆报工guid = 合同分拆报工dtos.bus_合同分拆报工.guid;
                    }
                }

                //更新到数据库

                //事务
                WebResponseContent webResponse = repository.DbContextBeginTransaction(() =>
                {
                    try
                    {
                        if (bus合同分拆 != null)
                        {
                            _repository合同分拆.Update(bus合同分拆, true);
                        }
                        //if (合同分拆报工dtos.bus_合同分拆报工人员明细List != null)
                        //{
                        //    _repositoryBus_合同分拆报工人员明细.AddRange(合同分拆报工dtos.bus_合同分拆报工人员明细List, true);
                        //}
                        if (合同分拆报工dtos.bus_合同分拆报工指标List != null)
                        {
                            _repository合同分拆报工指标.AddRange(合同分拆报工dtos.bus_合同分拆报工指标List, true);
                        }
                        if (合同分拆报工dtos.bus_合同分拆报工 != null)
                        {
                            _repository.Add(合同分拆报工dtos.bus_合同分拆报工, true);
                        }
                        //如果想要回滚，返回new WebResponseContent().Error("返回消息")
                        return new WebResponseContent().OK();
                    }
                    catch (Exception ex)
                    {
                        VOL.Core.Services.Logger.Info("2班组提交报工,数据库报错:" + ex.StackTrace);
                        return new WebResponseContent().Error("报工失败");
                        throw;
                    }
                });
                if (webResponse.Status)
                {
                    webResponse.Message = "报工成功";
                }
                else
                {
                    webResponse.Message = "报工失败";
                }
                return webResponse;

            }
            else
            {
                webResponseContent.Message = "未查询到你的班组信息。你可能不是班组长";
                return webResponseContent;
            }

            //_repository.AddRange(合同分拆报工dtos.bus_合同分拆报工List, true);
            //webResponseContent.Message = "报工数据不能为空";
            //return webResponseContent;
        }
        private bool 检查外包报工时间冲突(string 班组, DateTime? 施工开始时间, DateTime? 施工结束时间)
        {
            bool flag = false;
            //string sql;
            //    sql = $"select * from Bus_合同分拆报工 where 施工人员='{施工人员}' " +
            //    $"and (施工开始时间 between '{施工开始时间}' and '{施工结束时间}' or 施工结束时间 between '{施工开始时间}' and '{施工结束时间}')";
            //有返回值说明冲突
            flag = _repository.Find(x => x.班组 == 班组 &&
            (
                 (施工开始时间 <= x.施工开始时间 && x.施工开始时间 <= 施工结束时间) ||
                 (施工开始时间 <= x.施工结束时间 && x.施工结束时间 <= 施工结束时间) ||
                 (x.施工开始时间 <= 施工开始时间 && 施工开始时间 <= x.施工结束时间) ||
                 (x.施工开始时间 <= 施工结束时间 && 施工结束时间 <= x.施工结束时间)
            )
            ).Any();

            return flag;
        }

        public List<Bus_合同分拆报工> GetWaiBaoYiBaoGongList(Bus_合同分拆报工 bus)
        {
            List<Bus_合同分拆报工> bus_合同分拆报工List = _repository.Find(it => it.Creator == UserContext.Current.UserName)
                                                                   .OrderByDescending(it => it.CreateDate).ToList();
            //_repository多条件查询
            string sql = "select * from Bus_合同分拆报工 where 1=1";
            if (string.IsNullOrEmpty(bus.总包合同项目名称) == false)
            {
                sql += $" and 总包合同项目名称 like '%{bus.总包合同项目名称}%'";
            }
            if (string.IsNullOrEmpty(bus.任务名称) == false)
            {
                sql += $" and 任务名称 like '%{bus.任务名称}%'";
            }
            sql += $" and Creator = '{UserContext.Current.UserName}'";
            sql += " order by CreateDate desc";
            bus_合同分拆报工List = DBServerProvider.SqlDapper.QueryList<Bus_合同分拆报工>(sql, null);
            return bus_合同分拆报工List;
        }
        public WebResponseContent DeleteWaiBaoYiBaoGong(Bus_合同分拆报工 bus)
        {
            WebResponseContent webResponseContent = new WebResponseContent();
            Bus_合同分拆报工 bus_ = _repository.FindFirst(it => it.guid == bus.guid);
            if (bus_ != null)
            {
                //如果bus.CreateDate不是今天，就不允许删除
                if (bus_.CreateDate.Value.Date != DateTime.Now.Date)
                {
                    webResponseContent.Message = "只能删除当天的报工,跨天的不能删除";
                    webResponseContent.Code = "1";
                    return webResponseContent;
                }
                var dic单据状态 = _repositoryDic_单据状态Repository.Find(it => it.单据名称 == "Bus_合同分拆报工" && it.单据状态名称 == bus_.分拆状态).First();
                //如果bus.分拆状态是已审核，就不允许删除
                if (dic单据状态.可编辑 == false)
                {
                    webResponseContent.Message = "已审核的报工不能删除";
                    webResponseContent.Code = "1";
                    return webResponseContent;
                }

                //删除 Bus_合同分拆报工 和其它明细
                //通过事务删除
                WebResponseContent webResponse = repository.DbContextBeginTransaction(() =>
                {
                    try
                    {
                        _repository.Delete(bus_);
                        var a = _repositoryBus_合同分拆报工人员明细.Find(it => it.合同分拆报工guid == bus_.guid).ToList();
                        var b = _repository合同分拆报工指标.Find(it => it.合同分拆报工guid == bus_.guid).ToList();
                        if (a != null && a.Count > 0)
                        {
                            foreach (var item in a)
                            {
                                _repositoryBus_合同分拆报工人员明细.Delete(item, true);
                            }
                        }
                        if (b != null && b.Count > 0)
                        {
                            foreach (var item in b)
                            {
                                _repository合同分拆报工指标.Delete(item, true);
                            }
                        }
                        //如果想要回滚，返回new WebResponseContent().Error("返回消息")
                        return new WebResponseContent().OK("删除成功");
                    }
                    catch (Exception ex)
                    {
                        return new WebResponseContent().Error("删除失败");
                        throw;
                    }
                });
                return webResponse;
            }
            else
            {
                webResponseContent.Message = "未查到报工信息，可能已经删除";
                return webResponseContent;
            }
        }
        #endregion
    }
}
